package org.luxor.commons.core.utils;

import java.math.BigDecimal;


/**
 * 大数据计算/格式化
 *
 * @author Mr.yan @date 2023/10/11
 */
public class NumberUtils {
    /**
     * 格式化为指定位小数的数字,返回未使用科学计数法表示的具有指定位数的字符串。
     * 该方法舍入模式：向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。
     * <pre>
     *  "3.1415926", 1          --> 3.1
     *  "3.1415926", 3          --> 3.142
     *  "3.1415926", 4          --> 3.1416
     * </pre>
     *
     * @param number    类型的数字对象
     * @param precision 小数精确度总位数,如2表示两位小数
     * @return 返回数字格式化后的字符串表示形式(注意返回的字符串未使用科学计数法)
     */
    public static String keepPrecision(String number, int precision) {
        BigDecimal bg = new BigDecimal(number);
        return bg.setScale(precision, BigDecimal.ROUND_HALF_UP).toPlainString();
    }

    /**
     * 格式化为指定位小数的数字,返回未使用科学计数法表示的具有指定位数的字符串。<br>
     * 该方法舍入模式：向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。<br>
     * 如果给定的数字没有小数，则转换之后将以0填充；例如：int 123  1 --> 123.0<br>
     * <b>注意：</b>如果精度要求比较精确请使用 keepPrecision(String number, int precision)方法
     *
     * @param number    类型的数字对象
     * @param precision 小数精确度总位数,如2表示两位小数
     * @return 返回数字格式化后的字符串表示形式(注意返回的字符串未使用科学计数法)
     */
    public static String keepPrecision(Number number, int precision) {
        return keepPrecision(String.valueOf(number), precision);
    }

    /**
     * 对double类型的数值保留指定位数的小数。<br>
     * 该方法舍入模式：向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。<br>
     * <b>注意：</b>如果精度要求比较精确请使用 keepPrecision(String number, int precision)方法
     *
     * @param number    要保留小数的数字
     * @param precision 小数位数
     * @return 返回数字格式化后的字符串表示形式(注意返回的字符串未使用科学计数法)
     */
    public static String keepPrecision(double number, int precision) {
        BigDecimal bg = new BigDecimal(number);
        return bg.setScale(precision, BigDecimal.ROUND_HALF_UP).toPlainString();
    }

    /**
     * 对double类型的数值保留指定位数的小数。<br>
     * 该方法舍入模式：零舍入模式。<br>
     * <b>注意：</b>如果精度要求比较精确请使用 keepPrecision(String number, int precision)方法
     *
     * @param number    要保留小数的数字
     * @param precision 小数位数
     * @return 返回数字格式化后的字符串表示形式(注意返回的字符串未使用科学计数法)
     */
    public static String keepPrecision(int precision, double number) {
        BigDecimal bg = new BigDecimal(number);
        return bg.setScale(precision, BigDecimal.ROUND_DOWN).toPlainString();
    }

    /**
     * 对float类型的数值保留指定位数的小数。<br>
     * 该方法舍入模式：向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。<br>
     * <b>注意：</b>如果精度要求比较精确请使用 keepPrecision(String number, int precision)方法
     *
     * @param number    要保留小数的数字
     * @param precision 小数位数
     * @return float 如果数值较大，则使用科学计数法表示
     */
    public static float keepPrecision(float number, int precision) {
        BigDecimal bg = new BigDecimal(number);
        return bg.setScale(precision, BigDecimal.ROUND_HALF_UP).floatValue();
    }

    /**
     * 计算两个int类型之间的百分比
     * <pre>
     *  "dividend：1,divisor:2",1  --> 50.0%
     *  "dividend：3,divisor:4",2  --> 75.00%
     *  "dividend：1,divisor:7",2  --> 14.29%
     * </pre>
     *
     * @param dividend  被除数
     * @param divisor   除数
     * @param precision 小数位数
     * @return 返回数字格式化后的字符串表示形式
     */
    public static String calculateRate(int dividend, int divisor, int precision) {
        if (divisor <= 0) {
            return keepPrecision(0.0d, precision) + "%";
        }
        double rate = Integer.valueOf(dividend).doubleValue() / Integer.valueOf(divisor).doubleValue();
        return keepPrecision(rate * 100, precision) + "%";
    }

    /**
     * 计算两个int类型之间的百分比(采用截短模式)
     *
     * @param dividend  被除数
     * @param divisor   除数
     * @param precision 小数位数
     * @return 返回数字格式化后的字符串表示形式
     */
    public static String calculateRateByTruncate(Long dividend, Long divisor, int precision) {
        if (divisor <= 0) {
            return keepPrecision(precision, 0.0d) + "%";
        }
        double rate = Long.valueOf(dividend).doubleValue() / Long.valueOf(divisor).doubleValue();
        return keepPrecision(precision, rate * 100) + "%";
    }

    /**
     * 处理大数值，保留两位小数
     *
     * @param val 除数
     * @param arg 被除数
     * @return
     */
    public static String formatData2Str(String val, int arg) {
        BigDecimal bd = new BigDecimal(val);
        return keepPrecision(bd.divide(new BigDecimal(arg)).toString(), 2);
    }

    /**
     * 处理大数值，保留两位小数
     *
     * @param val 除数
     * @param arg 被除数
     * @return
     */
    public static float formatData2Float(String val, int arg) {
        BigDecimal bd = new BigDecimal(val);
        return Float.parseFloat(keepPrecision(bd.divide(new BigDecimal(arg)).toString(), 2));
    }

    public static void main(String[] args) {
        BigDecimal bd = new BigDecimal("12345678901234578.789");
        System.out.println("BigDecimal * 12.5=" + (bd = bd.multiply(new BigDecimal(12.5))));
        System.out.println("BigDecimal / 12.5=" + bd.divide(new BigDecimal(100000)));

        System.out.println(formatData2Str("1234567890123457", 100000));
        System.out.println(formatData2Float("1234567890123457", 1000000000));
    }

}
